home *** CD-ROM | disk | FTP | other *** search
/ CICA 1997 August / CICA - The Ultimate Collection of Shareware for Windows (Walnut Creek) (August 1997) (Disc 1).iso / utils / unix / unzip520 / extract.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-25  |  57.3 KB  |  1,503 lines
  1. /*---------------------------------------------------------------------------
  2.  
  3.   extract.c
  4.  
  5.   This file contains the high-level routines ("driver routines") for extrac-
  6.   ting and testing zipfile members.  It calls the low-level routines in files
  7.   explode.c, inflate.c, unreduce.c and unshrink.c.
  8.  
  9.   Contains:  extract_or_test_files()
  10.              store_info()
  11.              extract_or_test_member()
  12.              TestExtraField()
  13.              test_OS2()
  14.              memextract()
  15.              memflush()
  16.              fnfilter()
  17.  
  18.   ---------------------------------------------------------------------------*/
  19.  
  20.  
  21. #define UNZIP_INTERNAL
  22. #include "unzip.h"
  23. #include "crypt.h"
  24. #ifdef MSWIN
  25. #  include "wingui\wizunzip.h"
  26. #  include "wingui\replace.h"
  27. #endif
  28.  
  29. #define GRRDUMP(buf,len) { \
  30.     int i, j; \
  31.  \
  32.     for (j = 0;  j < (len)/16;  ++j) { \
  33.         printf("        "); \
  34.         for (i = 0;  i < 16;  ++i) \
  35.             printf("%02x ", (uch)(buf)[i+(j<<4)]); \
  36.         printf("\n        "); \
  37.         for (i = 0;  i < 16;  ++i) { \
  38.             char c = (char)(buf)[i+(j<<4)]; \
  39.  \
  40.             if (c == '\n') \
  41.                 printf("\\n "); \
  42.             else if (c == '\r') \
  43.                 printf("\\r "); \
  44.             else \
  45.                 printf(" %c ", c); \
  46.         } \
  47.         printf("\n"); \
  48.     } \
  49.     if ((len) % 16) { \
  50.         printf("        "); \
  51.         for (i = j<<4;  i < (len);  ++i) \
  52.             printf("%02x ", (uch)(buf)[i]); \
  53.         printf("\n        "); \
  54.         for (i = j<<4;  i < (len);  ++i) { \
  55.             char c = (char)(buf)[i]; \
  56.  \
  57.             if (c == '\n') \
  58.                 printf("\\n "); \
  59.             else if (c == '\r') \
  60.                 printf("\\r "); \
  61.             else \
  62.                 printf(" %c ", c); \
  63.         } \
  64.         printf("\n"); \
  65.     } \
  66. }
  67.  
  68. static int store_info OF((__GPRO));
  69. static int extract_or_test_member OF((__GPRO));
  70. static int TestExtraField OF((__GPRO__ uch *ef, unsigned ef_len));
  71. static int test_OS2 OF((__GPRO__ uch *eb, unsigned eb_size));
  72.  
  73.  
  74.  
  75. /*******************************/
  76. /*  Strings used in extract.c  */
  77. /*******************************/
  78.  
  79. static char Far VersionMsg[] =
  80.   "   skipping: %-22s  need %s compat. v%u.%u (can do v%u.%u)\n";
  81. static char Far ComprMsg[] =
  82.   "   skipping: %-22s  unsupported compression method %d\n";
  83. static char Far FilNamMsg[] =
  84.   "%s:  bad filename length (%s)\n";
  85. static char Far ExtFieldMsg[] =
  86.   "%s:  bad extra field length (%s)\n";
  87. static char Far OffsetMsg[] =
  88.   "file #%d:  bad zipfile offset (%s):  %ld\n";
  89. static char Far ExtractMsg[] =
  90.   "%8sing: %-22s  %s%s";
  91. #ifndef SFX
  92.    static char Far LengthMsg[] =
  93.      "%s  %s:  %ld bytes required to uncompress to %lu bytes;\n    %s\
  94.       supposed to require %lu bytes%s%s%s\n";
  95. #endif
  96.  
  97. static char Far BadFileCommLength[] = "%s:  bad file comment length\n";
  98. static char Far LocalHdrSig[] = "local header sig";
  99. static char Far BadLocalHdr[] = "file #%d:  bad local header\n";
  100. static char Far AttemptRecompensate[] = "  (attempting to re-compensate)\n";
  101. static char Far BackslashPathSep[] =
  102.   "warning:  %s appears to use backslashes as path separators\n";
  103. static char Far SkipVolumeLabel[] = "   skipping: %-22s  %svolume label\n";
  104.  
  105. #ifndef MSWIN
  106.    static char Far ReplaceQuery[] =
  107.      "replace %s? [y]es, [n]o, [A]ll, [N]one, [r]ename: ";
  108.    static char Far AssumeNone[] = " NULL\n(assuming [N]one)\n";
  109.    static char Far NewNameQuery[] = "new name: ";
  110.    static char Far InvalidResponse[] = "error:  invalid response [%c]\n";
  111. #endif /* !MSWIN */
  112.  
  113. static char Far ErrorInArchive[] = "At least one %serror was detected in %s.\n";
  114. static char Far ZeroFilesTested[] = "Caution:  zero files tested in %s.\n";
  115.  
  116. #ifndef VMS
  117.    static char Far VMSFormatQuery[] =
  118.      "\n%s:  stored in VMS format.  Extract anyway? (y/n) ";
  119. #endif
  120.  
  121. #ifdef CRYPT
  122.    static char Far SkipCantGetPasswd[] =
  123.      "   skipping: %-22s  unable to get password\n";
  124.    static char Far SkipIncorrectPasswd[] =
  125.      "   skipping: %-22s  incorrect password\n";
  126.    static char Far FilesSkipBadPasswd[] =
  127.      "%d file%s skipped because of incorrect password.\n";
  128.    static char Far MaybeBadPasswd[] =
  129.      "    (may instead be incorrect password)\n";
  130. #else
  131.    static char Far SkipEncrypted[] =
  132.      "   skipping: %-22s  encrypted (not supported)\n";
  133. #endif
  134.  
  135. static char Far NoErrInCompData[] =
  136.   "No errors detected in compressed data of %s.\n";
  137. static char Far NoErrInTestedFiles[] =
  138.   "No errors detected in %s for the %d file%s tested.\n";
  139. static char Far FilesSkipped[] =
  140.   "%d file%s skipped because of unsupported compression or encoding.\n";
  141.  
  142. static char Far ErrUnzipFile[] = "  error:  %s%s %s\n";
  143. static char Far ErrUnzipNoFile[] = "\n  error:  %s%s\n";
  144. static char Far NotEnoughMem[] = "not enough memory to ";
  145. static char Far InvalidComprData[] = "invalid compressed data to ";
  146. static char Far Inflate[] = "inflate";
  147.  
  148. #ifndef SFX
  149.    static char Far Explode[] = "explode";
  150.    static char Far Unshrink[] = "unshrink";
  151. #endif
  152.  
  153. static char Far FileUnknownCompMethod[] = "%s:  unknown compression method\n";
  154. static char Far BadCRC[] = " bad CRC %08lx  (should be %08lx)\n";
  155.  
  156. static char Far InconsistEFlength[] =
  157.   "bad EF entry: block length %u > rest EF_size %u\n";
  158.       /* TruncEAs[] also used in OS/2 mapname(), close_outfile() */
  159. char Far TruncEAs[] = " compressed EA data missing (%d bytes)%s";
  160. static char Far InvalidComprDataEAs[] = " invalid compressed data for EAs\n";
  161. static char Far BadCRC_EAs[] = " bad CRC for extended attributes\n";
  162. static char Far UnknComprMethodEAs[] =
  163.   " unknown compression method for EAs (%u)\n";
  164. static char Far NotEnoughMemEAs[] = " out of memory while inflating EAs\n";
  165. static char Far UnknErrorEAs[] = " unknown error on extended attributes\n";
  166.  
  167. static char Far UnsupportedExtraField[] =
  168.   "\nerror:  unsupported extra field compression type (%u)--skipping\n";
  169. static char Far BadExtraFieldCRC[] =
  170.   "error [%s]:  bad extra field CRC %08lx (should be %08lx)\n";
  171.  
  172.  
  173.  
  174.  
  175.  
  176. /**************************************/
  177. /*  Function extract_or_test_files()  */
  178. /**************************************/
  179.  
  180. int extract_or_test_files(__G)    /* return PK-type error code */
  181.      __GDEF
  182. {
  183.     uch *cd_inptr;
  184.     int i, j, cd_incnt, renamed, query, filnum=(-1), blknum=0;
  185.     int error, error_in_archive=PK_COOL, *fn_matched=NULL, *xn_matched=NULL;
  186. #ifndef MSWIN
  187.     int len;
  188. #endif
  189.     ush members_remaining, num_skipped=0, num_bad_pwd=0;
  190.     long cd_bufstart, bufstart, inbuf_offset, request;
  191.     LONGINT old_extra_bytes=0L;
  192.     /* static min_info info[DIR_BLKSIZ]; moved to globals.h */
  193.  
  194.  
  195. /*---------------------------------------------------------------------------
  196.     The basic idea of this function is as follows.  Since the central di-
  197.     rectory lies at the end of the zipfile and the member files lie at the
  198.     beginning or middle or wherever, it is not very desirable to simply
  199.     read a central directory entry, jump to the member and extract it, and
  200.     then jump back to the central directory.  In the case of a large zipfile
  201.     this would lead to a whole lot of disk-grinding, especially if each mem-
  202.     ber file is small.  Instead, we read from the central directory the per-
  203.     tinent information for a block of files, then go extract/test the whole
  204.     block.  Thus this routine contains two small(er) loops within a very
  205.     large outer loop:  the first of the small ones reads a block of files
  206.     from the central directory; the second extracts or tests each file; and
  207.     the outer one loops over blocks.  There's some file-pointer positioning
  208.     stuff in between, but that's about it.  Btw, it's because of this jump-
  209.     ing around that we can afford to be lenient if an error occurs in one of
  210.     the member files:  we should still be able to go find the other members,
  211.     since we know the offset of each from the beginning of the zipfile.
  212.   ---------------------------------------------------------------------------*/
  213.  
  214.     G.pInfo = G.info;
  215.     members_remaining = G.ecrec.total_entries_central_dir;
  216. #if (defined(CRYPT) || !defined(NO_ZIPINFO))
  217.     G.newzip = TRUE;
  218.     G.reported_backslash = FALSE;
  219. #endif
  220.  
  221.     /* malloc space for check on unmatched filespecs (OK if one or both NULL) */
  222.     if (G.filespecs > 0  &&
  223.         (fn_matched=(int *)malloc(G.filespecs*sizeof(int))) != (int *)NULL)
  224.         for (i = 0;  i < G.filespecs;  ++i)
  225.             fn_matched[i] = FALSE;
  226.     if (G.xfilespecs > 0  &&
  227.         (xn_matched=(int *)malloc(G.xfilespecs*sizeof(int))) != (int *)NULL)
  228.         for (i = 0;  i < G.xfilespecs;  ++i)
  229.             xn_matched[i] = FALSE;
  230.  
  231. /*---------------------------------------------------------------------------
  232.     Begin main loop over blocks of member files.  We know the entire central
  233.     directory is on this disk:  we would not have any of this information un-
  234.     less the end-of-central-directory record was on this disk, and we would
  235.     not have gotten to this routine unless this is also the disk on which
  236.     the central directory starts.  In practice, this had better be the ONLY
  237.     disk in the archive, but we'll add multi-disk support soon.
  238.   ---------------------------------------------------------------------------*/
  239.  
  240.     while (members_remaining) {
  241.         j = 0;
  242. #ifdef AMIGA
  243.         memzero(G.filenotes, DIR_BLKSIZ * sizeof(char *));
  244. #endif
  245.  
  246.         /*
  247.          * Loop through files in central directory, storing offsets, file
  248.          * attributes, case-conversion and text-conversion flags until block
  249.          * size is reached.
  250.          */
  251.  
  252.         while (members_remaining && (j < DIR_BLKSIZ)) {
  253.             --members_remaining;
  254.             G.pInfo = &G.info[j];
  255.  
  256.             if (readbuf(__G__ G.sig, 4) == 0) {
  257.                 error_in_archive = PK_EOF;
  258.                 members_remaining = 0;  /* ...so no more left to do */
  259.                 break;
  260.             }
  261.             if (strncmp(G.sig, G.central_hdr_sig, 4)) {  /* just to make sure */
  262.                 Info(slide, 0x401, ((char *)slide, LoadFarString(CentSigMsg), j));
  263.                 Info(slide, 0x401, ((char *)slide, LoadFarString(ReportMsg)));
  264.                 error_in_archive = PK_BADERR;
  265.                 members_remaining = 0;  /* ...so no more left to do */
  266.                 break;
  267.             }
  268.             /* process_cdir_file_hdr() sets pInfo->hostnum, pInfo->lcflag */
  269.             if ((error = process_cdir_file_hdr(__G)) != PK_COOL) {
  270.                 error_in_archive = error;   /* only PK_EOF defined */
  271.                 members_remaining = 0;  /* ...so no more left to do */
  272.                 break;
  273.             }
  274.             if ((error = do_string(__G__ G.crec.filename_length, DS_FN)) !=
  275.                  PK_COOL)
  276.             {
  277.                 if (error > error_in_archive)
  278.                     error_in_archive = error;
  279.                 if (error > PK_WARN) {  /* fatal:  no more left to do */
  280.                     Info(slide, 0x401, ((char *)slide, LoadFarString(FilNamMsg),
  281.                       fnfilter(G.filename, slide + WSIZE / 2), "central"));
  282.                     members_remaining = 0;
  283.                     break;
  284.                 }
  285.             }
  286.             if ((error = do_string(__G__ G.crec.extra_field_length,
  287.                 EXTRA_FIELD)) != 0)
  288.             {
  289.                 if (error > error_in_archive)
  290.                     error_in_archive = error;
  291.                 if (error > PK_WARN) {  /* fatal */
  292.                     Info(slide, 0x401, ((char *)slide,
  293.                       LoadFarString(ExtFieldMsg),
  294.                       fnfilter(G.filename, slide + WSIZE / 2), "central"));
  295.                     members_remaining = 0;
  296.                     break;
  297.                 }
  298.             }
  299. #ifdef AMIGA
  300.             G.filenote_slot = j;
  301.             if ((error = do_string(__G__ G.crec.file_comment_length,
  302.                                    G.N_flag ? FILENOTE : SKIP)) != PK_COOL)
  303. #else
  304.             if ((error = do_string(__G__ G.crec.file_comment_length, SKIP))
  305.                 != PK_COOL)
  306. #endif
  307.             {
  308.                 if (error > error_in_archive)
  309.                     error_in_archive = error;
  310.                 if (error > PK_WARN) {  /* fatal */
  311.                     Info(slide, 0x421, ((char *)slide,
  312.                       LoadFarString(BadFileCommLength),
  313.                       fnfilter(G.filename, slide + WSIZE / 2)));
  314.                     members_remaining = 0;
  315.                     break;
  316.                 }
  317.             }
  318.             if (G.process_all_files) {
  319.                 if (store_info(__G))
  320.                     ++j;  /* file is OK; info[] stored; continue with next */
  321.                 else
  322.                     ++num_skipped;
  323.             } else {
  324.                 int   do_this_file = FALSE;
  325.                 char  **pfn = G.pfnames-1;
  326.  
  327.                 while (*++pfn)
  328.                     if (match(G.filename, *pfn, G.C_flag)) {
  329.                         do_this_file = TRUE;   /* ^-- ignore case or not? */
  330.                         if (fn_matched)
  331.                             fn_matched[(int)(pfn-G.pfnames)] = TRUE;
  332.                         break;       /* found match, so stop looping */
  333.                     }
  334.                 if (do_this_file) {  /* check if this is an excluded file */
  335.                     char  **pxn = G.pxnames-1;
  336.  
  337.                     while (*++pxn)
  338.                         if (match(G.filename, *pxn, G.C_flag)) {
  339.                             do_this_file = FALSE;  /* ^-- ignore case or not? */
  340.                             if (xn_matched)
  341.                                 xn_matched[(int)(pxn-G.pxnames)] = TRUE;
  342.                             break;
  343.                         }
  344.                 }
  345.                 if (do_this_file)
  346.                     if (store_info(__G))
  347.                         ++j;            /* file is OK */
  348.                     else
  349.                         ++num_skipped;  /* unsupp. compression or encryption */
  350.             } /* end if (process_all_files) */
  351.  
  352.  
  353.         } /* end while-loop (adding files to current block) */
  354.  
  355.         /* save position in central directory so can come back later */
  356.         cd_bufstart = G.cur_zipfile_bufstart;
  357.         cd_inptr = G.inptr;
  358.         cd_incnt = G.incnt;
  359.  
  360.     /*-----------------------------------------------------------------------
  361.         Second loop:  process files in current block, extracting or testing
  362.         each one.
  363.       -----------------------------------------------------------------------*/
  364.  
  365.         for (i = 0; i < j; ++i) {
  366.             filnum = i + blknum*DIR_BLKSIZ;
  367.             G.pInfo = &G.info[i];
  368. #ifdef NOVELL_BUG_FAILSAFE
  369.             G.dne = FALSE;  /* assume file exists until stat() says otherwise */
  370. #endif
  371.  
  372.             /* if the target position is not within the current input buffer
  373.              * (either haven't yet read far enough, or (maybe) skipping back-
  374.              * ward), skip to the target position and reset readbuf(). */
  375.  
  376.             /* ZLSEEK(pInfo->offset):  */
  377.             request = G.pInfo->offset + G.extra_bytes;
  378.             inbuf_offset = request % INBUFSIZ;
  379.             bufstart = request - inbuf_offset;
  380.  
  381.             Trace((stderr, "\ndebug: request = %ld, inbuf_offset = %ld\n",
  382.               request, inbuf_offset));
  383.             Trace((stderr,
  384.               "debug: bufstart = %ld, cur_zipfile_bufstart = %ld\n",
  385.               bufstart, G.cur_zipfile_bufstart));
  386.             if (request < 0) {
  387.                 Info(slide, 0x401, ((char *)slide, LoadFarStringSmall(SeekMsg),
  388.                   G.zipfn, LoadFarString(ReportMsg)));
  389.                 error_in_archive = PK_ERR;
  390.                 if (filnum == 0 && G.extra_bytes != 0L) {
  391.                     Info(slide, 0x401, ((char *)slide,
  392.                       LoadFarString(AttemptRecompensate)));
  393.                     old_extra_bytes = G.extra_bytes;
  394.                     G.extra_bytes = 0L;
  395.                     request = G.pInfo->offset; /* could also check if this != 0 */
  396.                     inbuf_offset = request % INBUFSIZ;
  397.                     bufstart = request - inbuf_offset;
  398.                     Trace((stderr, "debug: request = %ld, inbuf_offset = %ld\n",
  399.                       request, inbuf_offset));
  400.                     Trace((stderr,
  401.                       "debug: bufstart = %ld, cur_zipfile_bufstart = %ld\n",
  402.                       bufstart, G.cur_zipfile_bufstart));
  403.                 } else {
  404.                     error_in_archive = PK_BADERR;
  405.                     continue;  /* this one hosed; try next */
  406.                 }
  407.             }
  408.             /* try again */
  409.             if (request < 0) {
  410.                 Trace((stderr, "debug: recompensated request still < 0\n"));
  411.                 Info(slide, 0x401, ((char *)slide, LoadFarStringSmall(SeekMsg),
  412.                   G.zipfn, LoadFarString(ReportMsg)));
  413.                 error_in_archive = PK_BADERR;
  414.                 continue;
  415.             } else if (bufstart != G.cur_zipfile_bufstart) {
  416.                 Trace((stderr, "debug: bufstart != cur_zipfile_bufstart\n"));
  417. #ifdef USE_STRM_INPUT
  418.                 fseek((FILE *)G.zipfd,(LONGINT)bufstart,SEEK_SET);
  419.                 G.cur_zipfile_bufstart = ftell((FILE *)G.zipfd);
  420. #else /* !USE_STRM_INPUT */
  421.                 G.cur_zipfile_bufstart =
  422.                   lseek(G.zipfd,(LONGINT)bufstart,SEEK_SET);
  423. #endif /* ?USE_STRM_INPUT */
  424.                 if ((G.incnt = read(G.zipfd,(char *)G.inbuf,INBUFSIZ)) <= 0)
  425.                 {
  426.                     Info(slide, 0x401, ((char *)slide, LoadFarString(OffsetMsg),
  427.                       filnum, "lseek", bufstart));
  428.                     error_in_archive = PK_BADERR;
  429.                     continue;   /* can still do next file */
  430.                 }
  431.                 G.inptr = G.inbuf + (int)inbuf_offset;
  432.                 G.incnt -= (int)inbuf_offset;
  433.             } else {
  434.                 G.incnt += (int)(G.inptr-G.inbuf) - (int)inbuf_offset;
  435.                 G.inptr = G.inbuf + (int)inbuf_offset;
  436.             }
  437.  
  438.             /* should be in proper position now, so check for sig */
  439.             if (readbuf(__G__ G.sig, 4) == 0) {  /* bad offset */
  440.                 Info(slide, 0x401, ((char *)slide, LoadFarString(OffsetMsg),
  441.                   filnum, "EOF", request));
  442.                 error_in_archive = PK_BADERR;
  443.                 continue;   /* but can still try next one */
  444.             }
  445.             if (strncmp(G.sig, G.local_hdr_sig, 4)) {
  446.                 Info(slide, 0x401, ((char *)slide, LoadFarString(OffsetMsg),
  447.                   filnum, LoadFarStringSmall(LocalHdrSig), request));
  448.                 /*
  449.                     GRRDUMP(G.sig, 4)
  450.                     GRRDUMP(G.local_hdr_sig, 4)
  451.                  */
  452.                 error_in_archive = PK_ERR;
  453.                 if ((filnum == 0 && G.extra_bytes != 0L) ||
  454.                     (G.extra_bytes == 0L && old_extra_bytes != 0L)) {
  455.                     Info(slide, 0x401, ((char *)slide,
  456.                       LoadFarString(AttemptRecompensate)));
  457.                     if (G.extra_bytes) {
  458.                         old_extra_bytes = G.extra_bytes;
  459.                         G.extra_bytes = 0L;
  460.                     } else
  461.                         G.extra_bytes = old_extra_bytes;  /* third attempt */
  462.                     ZLSEEK(G.pInfo->offset)
  463.                     if (readbuf(__G__ G.sig, 4) == 0) {  /* bad offset */
  464.                         Info(slide, 0x401, ((char *)slide,
  465.                           LoadFarString(OffsetMsg), filnum, "EOF", request));
  466.                         error_in_archive = PK_BADERR;
  467.                         continue;   /* but can still try next one */
  468.                     }
  469.                     if (strncmp(G.sig, G.local_hdr_sig, 4)) {
  470.                         Info(slide, 0x401, ((char *)slide,
  471.                           LoadFarString(OffsetMsg), filnum,
  472.                           LoadFarStringSmall(LocalHdrSig), request));
  473.                         error_in_archive = PK_BADERR;
  474.                         continue;
  475.                     }
  476.                 } else
  477.                     continue;  /* this one hosed; try next */
  478.             }
  479.             if ((error = process_local_file_hdr(__G)) != PK_COOL) {
  480.                 Info(slide, 0x421, ((char *)slide, LoadFarString(BadLocalHdr),
  481.                   filnum));
  482.                 error_in_archive = error;   /* only PK_EOF defined */
  483.                 continue;   /* can still try next one */
  484.             }
  485.             if ((error = do_string(__G__ G.lrec.filename_length, DS_FN)) !=
  486.                  PK_COOL)
  487.             {
  488.                 if (error > error_in_archive)
  489.                     error_in_archive = error;
  490.                 if (error > PK_WARN) {
  491.                     Info(slide, 0x401, ((char *)slide, LoadFarString(FilNamMsg),
  492.                       fnfilter(G.filename, slide + WSIZE / 2), "local"));
  493.                     continue;   /* go on to next one */
  494.                 }
  495.             }
  496.             if (G.extra_field != (uch *)NULL) {
  497.                 free(G.extra_field);
  498.                 G.extra_field = (uch *)NULL;
  499.             }
  500.             if ((error =
  501.                  do_string(__G__ G.lrec.extra_field_length,EXTRA_FIELD)) != 0)
  502.             {
  503.                 if (error > error_in_archive)
  504.                     error_in_archive = error;
  505.                 if (error > PK_WARN) {
  506.                     Info(slide, 0x401, ((char *)slide,
  507.                       LoadFarString(ExtFieldMsg),
  508.                       fnfilter(G.filename, slide + WSIZE / 2), "local"));
  509.                     continue;   /* go on */
  510.                 }
  511.             }
  512.  
  513.             /*
  514.              * just about to extract file:  if extracting to disk, check if
  515.              * already exists, and if so, take appropriate action according to
  516.              * fflag/uflag/overwrite_all/etc. (we couldn't do this in upper
  517.              * loop because we don't store the possibly renamed filename[] in
  518.              * info[])
  519.              */
  520. #ifdef DLL
  521.             if (!G.tflag && !G.cflag && !G.redirect_data)
  522. #else
  523.             if (!G.tflag && !G.cflag)
  524. #endif
  525.             {
  526.                 renamed = FALSE;   /* user hasn't renamed output file yet */
  527.  
  528. startover:
  529.                 query = FALSE;
  530. #ifdef MACOS
  531.                 G.macflag = (G.pInfo->hostnum == MAC_);
  532. #endif
  533.                 /* for files from DOS FAT, check for use of backslash instead
  534.                  *  of slash as directory separator (bug in some zipper(s); so
  535.                  *  far, not a problem in HPFS, NTFS or VFAT systems)
  536.                  */
  537.                 if (G.pInfo->hostnum == FS_FAT_ && !strchr(G.filename, '/')) {
  538.                     char *p=G.filename-1;
  539.  
  540.                     while (*++p) {
  541.                         if (*p == '\\') {
  542.                             if (!G.reported_backslash) {
  543.                                 Info(slide, 0x21, ((char *)slide,
  544.                                   LoadFarString(BackslashPathSep), G.zipfn));
  545.                                 G.reported_backslash = TRUE;
  546.                                 if (!error_in_archive)
  547.                                     error_in_archive = PK_WARN;
  548.                             }
  549.                             *p = '/';
  550.                         }
  551.                     }
  552.                 }
  553.  
  554.                 /* mapname can create dirs if not freshening or if renamed */
  555.                 if ((error = mapname(__G__ renamed)) > PK_WARN) {
  556.                     if (error == IZ_CREATED_DIR) {
  557.  
  558.                         /* GRR:  add code to set times/attribs on dirs--
  559.                          * save to list, sort when done (a la zip), set
  560.                          * times/attributes on deepest dirs first */
  561.  
  562.                     } else if (error == IZ_VOL_LABEL) {
  563. #ifdef DOS_OS2_W32
  564.                         Info(slide, 0x401, ((char *)slide,
  565.                           LoadFarString(SkipVolumeLabel),
  566.                           fnfilter(G.filename, slide + WSIZE / 2),
  567.                           G.volflag? "hard disk " : ""));
  568. #else
  569.                         Info(slide, 1, ((char *)slide,
  570.                           LoadFarString(SkipVolumeLabel),
  571.                           fnfilter(G.filename, slide + WSIZE / 2), ""));
  572. #endif
  573.                     /*  if (!error_in_archive)
  574.                             error_in_archive = PK_WARN;  */
  575.                     } else if (error > PK_ERR  &&  error_in_archive < PK_ERR)
  576.                         error_in_archive = PK_ERR;
  577.                     Trace((stderr, "mapname(%s) returns error = %d\n",
  578.                       G.filename, error));
  579.                     continue;   /* go on to next file */
  580.                 }
  581.  
  582.                 switch (check_for_newer(__G__ G.filename)) {
  583.                     case DOES_NOT_EXIST:
  584. #ifdef NOVELL_BUG_FAILSAFE
  585.                         G.dne = TRUE;   /* stat() says file DOES NOT EXIST */
  586. #endif
  587.                         /* if freshening, don't skip if just renamed */
  588.                         if (G.fflag && !renamed)
  589.                             continue;   /* freshen (no new files):  skip */
  590.                         break;
  591.                     case EXISTS_AND_OLDER:
  592.                         if (G.overwrite_none) {
  593. #ifdef MSWIN
  594.                             char szStr[WIZUNZIP_MAX_PATH];
  595.                             if (!lpDCL->PromptToOverwrite) {
  596.                                 sprintf(szStr,
  597.                                   "Target file exists.\nSkipping %s\n",
  598.                                   G.filename);
  599.                                 win_fprintf(stdout, strlen(szStr), szStr);
  600.                             } else {
  601.                                 query = TRUE;
  602.                                 break;
  603.                             }
  604. #endif
  605.                             continue;   /* never overwrite:  skip file */
  606.                         }
  607.                         if (!G.overwrite_all)
  608.                             query = TRUE;
  609.                         break;
  610.                     case EXISTS_AND_NEWER:             /* (or equal) */
  611.                         if (G.overwrite_none || (G.uflag && !renamed)) {
  612. #ifdef MSWIN
  613.                             char szStr[WIZUNZIP_MAX_PATH];
  614.                             if (!lpDCL->PromptToOverwrite) {
  615.                                 sprintf(szStr,
  616.                                   "Target file newer.\nSkipping %s\n",
  617.                                   G.filename);
  618.                                 win_fprintf(stdout, strlen(szStr), szStr);
  619.                             } else {
  620.                                 query = TRUE;
  621.                                 break;
  622.                             }
  623. #endif
  624.                             continue;  /* skip if update/freshen & orig name */
  625.                         }
  626.                         if (!G.overwrite_all)
  627.                             query = TRUE;
  628.                         break;
  629.                 }
  630.                 if (query) {
  631. #ifdef MSWIN
  632.                     switch (GetReplaceDlgRetVal()) {
  633.                         case IDM_REPLACE_RENAME:
  634.                             renamed = TRUE;
  635.                             goto startover;
  636.                         case IDM_REPLACE_YES:
  637.                             break;
  638.                         case IDM_REPLACE_ALL:
  639.                             G.overwrite_all = TRUE;
  640.                             G.overwrite_none = FALSE;  /* just to make sure */
  641.                             break;
  642.                         case IDM_REPLACE_NONE:
  643.                             G.overwrite_none = TRUE;
  644.                             G.overwrite_all = FALSE;  /* make sure */
  645.                             /* FALL THROUGH, skip */
  646.                         case IDM_REPLACE_NO:
  647.                             continue;
  648.                     }
  649. #else /* !MSWIN */
  650. reprompt:
  651.                     Info(slide, 0x81, ((char *)slide,
  652.                       LoadFarString(ReplaceQuery), G.filename));
  653.                     if (fgets(G.answerbuf, 9, stdin) == (char *)NULL) {
  654.                         Info(slide, 1, ((char *)slide,
  655.                           LoadFarString(AssumeNone)));
  656.                         *G.answerbuf = 'N';
  657.                         if (!error_in_archive)
  658.                             error_in_archive = 1;  /* not extracted:  warning */
  659.                     }
  660.                     switch (*G.answerbuf) {
  661.                         case 'A':   /* dangerous option:  force caps */
  662.                             G.overwrite_all = TRUE;
  663.                             G.overwrite_none = FALSE;  /* just to make sure */
  664.                             break;
  665.                         case 'r':
  666.                         case 'R':
  667.                             do {
  668.                                 Info(slide, 0x81, ((char *)slide,
  669.                                   LoadFarString(NewNameQuery)));
  670.                                 fgets(G.filename, FILNAMSIZ, stdin);
  671.                                 /* usually get \n here:  better check for it */
  672.                                 len = strlen(G.filename);
  673.                                 if (G.filename[len-1] == '\n')
  674.                                     G.filename[--len] = 0;
  675.                             } while (len == 0);
  676.                             renamed = TRUE;
  677.                             goto startover;   /* sorry for a goto */
  678.                         case 'y':
  679.                         case 'Y':
  680.                             break;
  681.                         case 'N':
  682.                             G.overwrite_none = TRUE;
  683.                             G.overwrite_all = FALSE;  /* make sure */
  684.                             /* FALL THROUGH, skip */
  685.                         case 'n':
  686.                             continue;   /* skip file */
  687.                         default:
  688.                             Info(slide, 1, ((char *)slide,
  689.                               LoadFarString(InvalidResponse), *G.answerbuf));
  690.                             goto reprompt;   /* yet another goto? */
  691.                     } /* end switch (*answerbuf) */
  692. #endif /* ?MSWIN */
  693.                 } /* end if (query) */
  694.             } /* end if (extracting to disk) */
  695.  
  696. #ifdef CRYPT
  697.             if (G.pInfo->encrypted && (error = decrypt(__G)) != PK_COOL) {
  698.                 if (error == PK_MEM2) {
  699.                     if (error > error_in_archive)
  700.                         error_in_archive = error;
  701.                     Info(slide, 0x401, ((char *)slide,
  702.                       LoadFarString(SkipCantGetPasswd),
  703.                       fnfilter(G.filename, slide + WSIZE / 2)));
  704.                 } else {  /* (error == PK_WARN) */
  705.                     if (!((G.tflag && G.qflag) || (!G.tflag && !QCOND2)))
  706.                         Info(slide, 0x401, ((char *)slide,
  707.                           LoadFarString(SkipIncorrectPasswd),
  708.                           fnfilter(G.filename, slide + WSIZE / 2)));
  709.                     ++num_bad_pwd;
  710.                 }
  711.                 continue;   /* go on to next file */
  712.             }
  713. #endif /* CRYPT */
  714. #ifdef MSWIN
  715.             /* play sound during extraction or test, if requested */
  716.             SoundDuring();
  717. #endif
  718. #ifdef AMIGA
  719.             G.filenote_slot = i;
  720. #endif
  721.             G.disk_full = 0;
  722.             if ((error = extract_or_test_member(__G)) != PK_COOL) {
  723.                 if (error > error_in_archive)
  724.                     error_in_archive = error;       /* ...and keep going */
  725.                 if (G.disk_full > 1) {
  726. #ifdef DYNALLOC_CRCTAB
  727.                     nearfree((zvoid near *)CRC_32_TAB);
  728. #endif /* DYNALLOC_CRCTAB */
  729.                     if (fn_matched)
  730.                         free((zvoid *)fn_matched);
  731.                     if (xn_matched)
  732.                         free((zvoid *)xn_matched);
  733.                     return error_in_archive;        /* (unless disk full) */
  734.                 }
  735.             }
  736.         } /* end for-loop (i:  files in current block) */
  737.  
  738.  
  739.         /*
  740.          * Jump back to where we were in the central directory, then go and do
  741.          * the next batch of files.
  742.          */
  743.  
  744. #ifdef USE_STRM_INPUT
  745.         fseek((FILE *)G.zipfd, (LONGINT)cd_bufstart, SEEK_SET);
  746.         G.cur_zipfile_bufstart = ftell((FILE *)G.zipfd);
  747. #else /* !USE_STRM_INPUT */
  748.         G.cur_zipfile_bufstart = lseek(G.zipfd,(LONGINT)cd_bufstart,SEEK_SET);
  749. #endif /* ?USE_STRM_INPUT */
  750.         read(G.zipfd, (char *)G.inbuf, INBUFSIZ);  /* been here before... */
  751.         G.inptr = cd_inptr;
  752.         G.incnt = cd_incnt;
  753.         ++blknum;
  754.  
  755. #ifdef TEST
  756.         printf("\ncd_bufstart = %ld (%.8lXh)\n", cd_bufstart, cd_bufstart);
  757.         printf("cur_zipfile_bufstart = %ld (%.8lXh)\n", cur_zipfile_bufstart,
  758.           cur_zipfile_bufstart);
  759.         printf("inptr-inbuf = %d\n", G.inptr-G.inbuf);
  760.         printf("incnt = %d\n\n", G.incnt);
  761. #endif
  762.  
  763.     } /* end while-loop (blocks of files in central directory) */
  764.  
  765. /*---------------------------------------------------------------------------
  766.     Check for unmatched filespecs on command line and print warning if any
  767.     found.  Free allocated memory.
  768.   ---------------------------------------------------------------------------*/
  769.  
  770.     if (fn_matched) {
  771.         for (i = 0;  i < G.filespecs;  ++i)
  772.             if (!fn_matched[i]) {
  773. #ifdef DLL
  774.                 if (!G.redirect_data && !G.redirect_text)
  775.                     Info(slide, 0x401, ((char *)slide,
  776.                       LoadFarString(FilenameNotMatched), G.pfnames[i]));
  777.                 else
  778.                     setFileNotFound(__G);
  779. #else
  780.                 Info(slide, 1, ((char *)slide, LoadFarString(FilenameNotMatched),
  781.                   G.pfnames[i]));
  782. #endif
  783.                 if (error_in_archive <= PK_WARN)
  784.                     error_in_archive = PK_FIND;   /* some files not found */
  785.             }
  786.         free((zvoid *)fn_matched);
  787.     }
  788.     if (xn_matched) {
  789.         for (i = 0;  i < G.xfilespecs;  ++i)
  790.             if (!xn_matched[i])
  791.                 Info(slide, 0x401, ((char *)slide,
  792.                   LoadFarString(ExclFilenameNotMatched), G.pxnames[i]));
  793.         free((zvoid *)xn_matched);
  794.     }
  795.  
  796. /*---------------------------------------------------------------------------
  797.     Double-check that we're back at the end-of-central-directory record, and
  798.     print quick summary of results, if we were just testing the archive.  We
  799.     send the summary to stdout so that people doing the testing in the back-
  800.     ground and redirecting to a file can just do a "tail" on the output file.
  801.   ---------------------------------------------------------------------------*/
  802.  
  803.     if (readbuf(__G__ G.sig, 4) == 0)
  804.         error_in_archive = PK_EOF;
  805.     if (strncmp(G.sig, G.end_central_sig, 4)) {         /* just to make sure */
  806.         Info(slide, 0x401, ((char *)slide, LoadFarString(EndSigMsg)));
  807.         Info(slide, 0x401, ((char *)slide, LoadFarString(ReportMsg)));
  808.         if (!error_in_archive)       /* don't overwrite stronger error */
  809.             error_in_archive = PK_WARN;
  810.     }
  811.     ++filnum;  /* initialized to -1, so now zero if no files found */
  812.     if (G.tflag) {
  813.         int num=filnum - num_bad_pwd;
  814.  
  815.         if (G.qflag < 2) {         /* GRR 930710:  was (G.qflag == 1) */
  816.             if (error_in_archive)
  817.                 Info(slide, 0, ((char *)slide, LoadFarString(ErrorInArchive),
  818.                   (error_in_archive == 1)? "warning-" : "", G.zipfn));
  819.             else if (num == 0)
  820.                 Info(slide, 0, ((char *)slide, LoadFarString(ZeroFilesTested),
  821.                   G.zipfn));
  822.             else if (G.process_all_files && (num_skipped+num_bad_pwd == 0))
  823.                 Info(slide, 0, ((char *)slide, LoadFarString(NoErrInCompData),
  824.                   G.zipfn));
  825.             else
  826.                 Info(slide, 0, ((char *)slide, LoadFarString(NoErrInTestedFiles)
  827.                   , G.zipfn, num, (num==1)? "":"s"));
  828.             if (num_skipped > 0)
  829.                 Info(slide, 0, ((char *)slide, LoadFarString(FilesSkipped),
  830.                   num_skipped, (num_skipped==1)? "":"s"));
  831. #ifdef CRYPT
  832.             if (num_bad_pwd > 0)
  833.                 Info(slide, 0, ((char *)slide, LoadFarString(FilesSkipBadPasswd)
  834.                   , num_bad_pwd, (num_bad_pwd==1)? "":"s"));
  835. #endif /* CRYPT */
  836.         } else if ((G.qflag == 0) && !error_in_archive && (num == 0))
  837.             Info(slide, 0, ((char *)slide, LoadFarString(ZeroFilesTested),
  838.               G.zipfn));
  839.     }
  840.  
  841.     /* give warning if files not tested or extracted (first condition can still
  842.      * happen if zipfile is empty and no files specified on command line) */
  843.     if ((filnum == 0) && error_in_archive <= PK_WARN)
  844.         error_in_archive = PK_FIND;   /* no files found at all */
  845.     else if ((num_skipped > 0) && !error_in_archive)
  846.         error_in_archive = PK_WARN;
  847. #ifdef CRYPT
  848.     else if ((num_bad_pwd > 0) && !error_in_archive)
  849.         error_in_archive = PK_WARN;
  850. #endif /* CRYPT */
  851.  
  852.     return error_in_archive;
  853.  
  854. } /* end function extract_or_test_files() */
  855.  
  856.  
  857.  
  858.  
  859.  
  860. /***************************/
  861. /*  Function store_info()  */
  862. /***************************/
  863.  
  864. static int store_info(__G)   /* return 0 if skipping, 1 if OK */
  865.      __GDEF
  866. {
  867. #ifdef SFX
  868. #  define UNKN_COMPR \
  869.    (G.crec.compression_method!=STORED && G.crec.compression_method!=DEFLATED)
  870. #else
  871. #  ifdef COPYRIGHT_CLEAN  /* no reduced or tokenized files */
  872. #    define UNKN_COMPR  (G.crec.compression_method>SHRUNK && \
  873.      G.crec.compression_method!=IMPLODED && G.crec.compression_method!=DEFLATED)
  874. #  else /* !COPYRIGHT_CLEAN */
  875. #    define UNKN_COMPR \
  876.      (G.crec.compression_method>IMPLODED && G.crec.compression_method!=DEFLATED)
  877. #  endif /* ?COPYRIGHT_CLEAN */
  878. #endif
  879.  
  880. /*---------------------------------------------------------------------------
  881.     Check central directory info for version/compatibility requirements.
  882.   ---------------------------------------------------------------------------*/
  883.  
  884.     G.pInfo->encrypted = G.crec.general_purpose_bit_flag & 1;       /* bit field */
  885.     G.pInfo->ExtLocHdr = (G.crec.general_purpose_bit_flag & 8) == 8;/* bit field */
  886.     G.pInfo->textfile = G.crec.internal_file_attributes & 1;        /* bit field */
  887.     G.pInfo->crc = G.crec.crc32;
  888.     G.pInfo->compr_size = G.crec.csize;
  889.  
  890.     switch (G.aflag) {
  891.         case 0:
  892.             G.pInfo->textmode = FALSE;   /* bit field */
  893.             break;
  894.         case 1:
  895.             G.pInfo->textmode = G.pInfo->textfile;   /* auto-convert mode */
  896.             break;
  897.         default:  /* case 2: */
  898.             G.pInfo->textmode = TRUE;
  899.             break;
  900.     }
  901.  
  902.     if (G.crec.version_needed_to_extract[1] == VMS_) {
  903.         if (G.crec.version_needed_to_extract[0] > VMS_UNZIP_VERSION) {
  904.             if (!((G.tflag && G.qflag) || (!G.tflag && !QCOND2)))
  905.                 Info(slide, 0x401, ((char *)slide, LoadFarString(VersionMsg),
  906.                   fnfilter(G.filename, slide + WSIZE / 2), "VMS",
  907.                   G.crec.version_needed_to_extract[0] / 10,
  908.                   G.crec.version_needed_to_extract[0] % 10,
  909.                   VMS_UNZIP_VERSION / 10, VMS_UNZIP_VERSION % 10));
  910.             return 0;
  911.         }
  912. #ifndef VMS   /* won't be able to use extra field, but still have data */
  913.         else if (!G.tflag && !G.overwrite_all) {   /* if -o, extract regardless */
  914.             Info(slide, 0x481, ((char *)slide, LoadFarString(VMSFormatQuery),
  915.               fnfilter(G.filename, slide + WSIZE / 2)));
  916.             fgets(G.answerbuf, 9, stdin);
  917.             if ((*G.answerbuf != 'y') && (*G.answerbuf != 'Y'))
  918.                 return 0;
  919.         }
  920. #endif /* !VMS */
  921.     /* usual file type:  don't need VMS to extract */
  922.     } else if (G.crec.version_needed_to_extract[0] > UNZIP_VERSION) {
  923.         if (!((G.tflag && G.qflag) || (!G.tflag && !QCOND2)))
  924.             Info(slide, 0x401, ((char *)slide, LoadFarString(VersionMsg),
  925.               fnfilter(G.filename, slide + WSIZE / 2), "PK",
  926.               G.crec.version_needed_to_extract[0] / 10,
  927.               G.crec.version_needed_to_extract[0] % 10,
  928.               UNZIP_VERSION / 10, UNZIP_VERSION % 10));
  929.         return 0;
  930.     }
  931.  
  932.     if UNKN_COMPR {
  933.         if (!((G.tflag && G.qflag) || (!G.tflag && !QCOND2)))
  934.             Info(slide, 0x401, ((char *)slide, LoadFarString(ComprMsg),
  935.               fnfilter(G.filename, slide + WSIZE / 2),
  936.               G.crec.compression_method));
  937.         return 0;
  938.     }
  939. #ifndef CRYPT
  940.     if (G.pInfo->encrypted) {
  941.         if (!((G.tflag && G.qflag) || (!G.tflag && !QCOND2)))
  942.             Info(slide, 0x401, ((char *)slide, LoadFarString(SkipEncrypted),
  943.               fnfilter(G.filename, slide + WSIZE / 2)));
  944.         return 0;
  945.     }
  946. #endif /* !CRYPT */
  947.  
  948.     /* map whatever file attributes we have into the local format */
  949.     mapattr(__G);   /* GRR:  worry about return value later */
  950.  
  951.     G.pInfo->offset = (long) G.crec.relative_offset_local_header;
  952.     return 1;
  953.  
  954. } /* end function store_info() */
  955.  
  956.  
  957.  
  958.  
  959.  
  960. /***************************************/
  961. /*  Function extract_or_test_member()  */
  962. /***************************************/
  963.  
  964. static int extract_or_test_member(__G)    /* return PK-type error code */
  965.      __GDEF
  966. {
  967.     char *nul="[empty] ", *txt="[text]  ", *bin="[binary]";
  968. #ifdef CMS_MVS
  969.     char *ebc="[ebcdic]";
  970. #endif
  971.     register int b;
  972.     int r, error=PK_COOL;
  973.     ulg wsize;
  974.  
  975.  
  976. /*---------------------------------------------------------------------------
  977.     Initialize variables, buffers, etc.
  978.   ---------------------------------------------------------------------------*/
  979.  
  980.     G.bits_left = 0;
  981.     G.bitbuf = 0L;       /* unreduce and unshrink only */
  982.     G.zipeof = 0;
  983.     G.newfile = TRUE;
  984.     G.crc32val = CRCVAL_INITIAL;
  985.  
  986. #ifdef SYMLINKS
  987.     /* if file came from Unix and is a symbolic link and we are extracting
  988.      * to disk, prepare to restore the link */
  989.     if (S_ISLNK(G.pInfo->file_attr) &&
  990.         (G.pInfo->hostnum == UNIX_ || G.pInfo->hostnum == ATARI_) &&
  991.         !G.tflag && !G.cflag && (G.lrec.ucsize > 0))
  992.         G.symlnk = TRUE;
  993.     else
  994.         G.symlnk = FALSE;
  995. #endif /* SYMLINKS */
  996.  
  997.     if (G.tflag) {
  998.         if (!G.qflag)
  999.             Info(slide, 0, ((char *)slide, LoadFarString(ExtractMsg), "test",
  1000.               fnfilter(G.filename, slide + WSIZE / 2), "", ""));
  1001.     } else {
  1002. #ifdef DLL
  1003.         if (G.cflag && !G.redirect_data)
  1004. #else
  1005.         if (G.cflag)
  1006. #endif
  1007.         {
  1008.             G.outfile = stdout;
  1009. #ifdef DOS_H68_OS2_W32
  1010. #ifdef __HIGHC__
  1011.             setmode(G.outfile, _BINARY);
  1012. #else
  1013.             setmode(fileno(G.outfile), O_BINARY);
  1014. #endif
  1015. #           define NEWLINE "\r\n"
  1016. #else /* !DOS_H68_OS2_W32 */
  1017. #           define NEWLINE "\n"
  1018. #endif /* ?DOS_H68_OS2_W32 */
  1019. #ifdef VMS
  1020.             if (open_outfile(__G))   /* VMS:  required even for stdout! */
  1021.                 return PK_DISK;
  1022. #endif
  1023.         } else if (open_outfile(__G))
  1024.             return PK_DISK;
  1025.     }
  1026.  
  1027. /*---------------------------------------------------------------------------
  1028.     Unpack the file.
  1029.   ---------------------------------------------------------------------------*/
  1030.  
  1031.     defer_leftover_input(__G);    /* so NEXTBYTE bounds check will work */
  1032.     switch (G.lrec.compression_method) {
  1033.         case STORED:
  1034.             if (!G.tflag && QCOND2) {
  1035. #ifdef SYMLINKS
  1036.                 if (G.symlnk)   /* can also be deflated, but rarer... */
  1037.                     Info(slide, 0, ((char *)slide, LoadFarString(ExtractMsg),
  1038.                       "link", G.filename, "", ""));
  1039.                 else
  1040. #endif /* SYMLINKS */
  1041.                 Info(slide, 0, ((char *)slide, LoadFarString(ExtractMsg),
  1042.                   "extract", G.filename,
  1043.                   (G.aflag != 1 /* && pInfo->textfile == pInfo->textmode */ )?
  1044.                   "" : (G.lrec.ucsize == 0L? nul : (G.pInfo->textfile? txt :
  1045.                   bin)), G.cflag? NEWLINE : ""));
  1046.             }
  1047. #ifdef DLL
  1048.             if (G.redirect_data)
  1049.                 wsize = G.redirect_size+1, G.outptr = G.redirect_buffer;
  1050.             else
  1051. #endif
  1052.                 wsize = WSIZE, G.outptr = slide;
  1053.             G.outcnt = 0L;
  1054.             while ((b = NEXTBYTE) != EOF && !G.disk_full) {
  1055.                 *G.outptr++ = (uch)b;
  1056.                 if (++G.outcnt == wsize) {
  1057.                     flush(__G__ slide, G.outcnt, 0);
  1058.                     G.outptr = slide;
  1059.                     G.outcnt = 0L;
  1060.                 }
  1061.             }
  1062. #ifdef DLL
  1063.             if (G.outcnt && !G.redirect_data)
  1064. #else
  1065.             if (G.outcnt)          /* flush final (partial) buffer */
  1066. #endif
  1067.                 flush(__G__ slide, G.outcnt, 0);
  1068.             break;
  1069.  
  1070. #ifndef SFX
  1071.         case SHRUNK:
  1072.             if (!G.tflag && QCOND2) {
  1073.                 Info(slide, 0, ((char *)slide, LoadFarString(ExtractMsg),
  1074.                   LoadFarStringSmall(Unshrink), G.filename,
  1075.                   (G.aflag != 1 /* && G.pInfo->textfile == G.pInfo->textmode */ )? ""
  1076.                   : (G.pInfo->textfile? txt : bin), G.cflag? NEWLINE : ""));
  1077.             }
  1078.             if ((r = unshrink(__G)) != PK_COOL) {
  1079.                 if ((G.tflag && G.qflag) || (!G.tflag && !QCOND2))
  1080.                     Info(slide, 0x401, ((char *)slide,
  1081.                       LoadFarStringSmall(ErrUnzipFile),
  1082.                       LoadFarString(NotEnoughMem),
  1083.                       LoadFarStringSmall2(Unshrink),
  1084.                       G.filename));
  1085.                 else
  1086.                     Info(slide, 0x401, ((char *)slide,
  1087.                       LoadFarStringSmall(ErrUnzipNoFile),
  1088.                       LoadFarString(NotEnoughMem),
  1089.                       LoadFarStringSmall2(Unshrink)));
  1090.                 error = r;
  1091.             }
  1092.             break;
  1093.  
  1094. #ifndef COPYRIGHT_CLEAN
  1095.         case REDUCED1:
  1096.         case REDUCED2:
  1097.         case REDUCED3:
  1098.         case REDUCED4:
  1099.             if (!G.tflag && QCOND2) {
  1100.                 Info(slide, 0, ((char *)slide, LoadFarString(ExtractMsg),
  1101.                   "unreduc", G.filename,
  1102.                   (G.aflag != 1 /* && G.pInfo->textfile == G.pInfo->textmode */ )? ""
  1103.                   : (G.pInfo->textfile? txt : bin), G.cflag? NEWLINE : ""));
  1104.             }
  1105.             unreduce(__G);
  1106.             break;
  1107. #endif /* !COPYRIGHT_CLEAN */
  1108.  
  1109.         case IMPLODED:
  1110.             if (!G.tflag && QCOND2) {
  1111.                 Info(slide, 0, ((char *)slide, LoadFarString(ExtractMsg),
  1112.                   "explod", G.filename,
  1113.                   (G.aflag != 1 /* && pInfo->textfile == pInfo->textmode */ )? ""
  1114.                   : (G.pInfo->textfile? txt : bin), G.cflag? NEWLINE : ""));
  1115.             }
  1116.             if (((r = explode(__G)) != 0) && (r != 5)) {   /* treat 5 specially */
  1117.                 if ((G.tflag && G.qflag) || (!G.tflag && !QCOND2))
  1118.                     Info(slide, 0x401, ((char *)slide,
  1119.                       LoadFarStringSmall(ErrUnzipFile), r == 3?
  1120.                       LoadFarString(NotEnoughMem) :
  1121.                       LoadFarString(InvalidComprData),
  1122.                       LoadFarStringSmall2(Explode), G.filename));
  1123.                 else
  1124.                     Info(slide, 0x401, ((char *)slide,
  1125.                       LoadFarStringSmall(ErrUnzipNoFile), r == 3?
  1126.                       LoadFarString(NotEnoughMem) :
  1127.                       LoadFarString(InvalidComprData),
  1128.                       LoadFarStringSmall2(Explode)));
  1129.                 error = (r == 3)? PK_MEM3 : PK_ERR;
  1130.             }
  1131.             if (r == 5) {
  1132.                 int warning = ((ulg)G.used_csize <= G.lrec.csize);
  1133.  
  1134.                 if ((G.tflag && G.qflag) || (!G.tflag && !QCOND2))
  1135.                     Info(slide, 0x401, ((char *)slide, LoadFarString(LengthMsg), "",
  1136.                       warning?  "warning" : "error", G.used_csize, G.lrec.ucsize,
  1137.                       warning?  "  " : "", G.lrec.csize, " [", G.filename, "]"));
  1138.                 else
  1139.                     Info(slide, 0x401, ((char *)slide, LoadFarString(LengthMsg),
  1140.                       "\n", warning? "warning" : "error", G.used_csize,
  1141.                       G.lrec.ucsize, warning? "  ":"", G.lrec.csize, "", "", "."));
  1142.                 error = warning? PK_WARN : PK_ERR;
  1143.             }
  1144.             break;
  1145. #endif /* !SFX */
  1146.  
  1147.         case DEFLATED:
  1148.             if (!G.tflag && QCOND2) {
  1149.                 Info(slide, 0, ((char *)slide, LoadFarString(ExtractMsg),
  1150.                   "inflat", G.filename,
  1151.                   (G.aflag != 1 /* && pInfo->textfile == pInfo->textmode */ )? ""
  1152.                   : (G.pInfo->textfile? txt : bin), G.cflag? NEWLINE : ""));
  1153.             }
  1154. #ifndef USE_ZLIB  /* zlib's function is called inflate(), too */
  1155. #  define UZinflate inflate
  1156. #endif
  1157.             if ((r = UZinflate(__G)) != 0) {
  1158.                 if ((G.tflag && G.qflag) || (!G.tflag && !QCOND2))
  1159.                     Info(slide, 0x401, ((char *)slide,
  1160.                       LoadFarStringSmall(ErrUnzipFile), r == 3?
  1161.                       LoadFarString(NotEnoughMem) :
  1162.                       LoadFarString(InvalidComprData),
  1163.                       LoadFarStringSmall2(Inflate), G.filename));
  1164.                 else
  1165.                     Info(slide, 0x401, ((char *)slide,
  1166.                       LoadFarStringSmall(ErrUnzipNoFile), r == 3?
  1167.                       LoadFarString(NotEnoughMem) :
  1168.                       LoadFarString(InvalidComprData),
  1169.                       LoadFarStringSmall2(Inflate)));
  1170.                 error = (r == 3)? PK_MEM3 : PK_ERR;
  1171.             }
  1172.             break;
  1173.  
  1174.         default:   /* should never get to this point */
  1175.             Info(slide, 0x401, ((char *)slide, LoadFarString(FileUnknownCompMethod),
  1176.               G.filename));
  1177.             /* close and delete file before return? */
  1178.             undefer_input(__G);
  1179.             return PK_WARN;
  1180.  
  1181.     } /* end switch (compression method) */
  1182.  
  1183.     if (G.disk_full) {            /* set by flush() */
  1184.         if (G.disk_full > 1) {
  1185.             undefer_input(__G);
  1186.             return PK_DISK;
  1187.         }
  1188.         error = PK_WARN;
  1189.     }
  1190.  
  1191. /*---------------------------------------------------------------------------
  1192.     Close the file and set its date and time (not necessarily in that order),
  1193.     and make sure the CRC checked out OK.  Logical-AND the CRC for 64-bit
  1194.     machines (redundant on 32-bit machines).
  1195.   ---------------------------------------------------------------------------*/
  1196.  
  1197. #ifdef VMS                  /* VMS:  required even for stdout! (final flush) */
  1198.     if (!G.tflag)          /* don't close NULL file */
  1199.         close_outfile(__G);
  1200. #else
  1201. #ifdef DLL
  1202.     if (!G.tflag && (!G.cflag || G.redirect_data))
  1203.         if (G.redirect_data)
  1204.             FINISH_REDIRECT();
  1205.         else
  1206.             close_outfile(__G);
  1207. #else
  1208.     if (!G.tflag && !G.cflag)   /* don't close NULL file or stdout */
  1209.         close_outfile(__G);
  1210. #endif
  1211. #endif /* VMS */
  1212.  
  1213.  
  1214.             /* GRR: CONVERT close_outfile() TO NON-VOID:  CHECK FOR ERRORS! */
  1215.  
  1216.  
  1217.     if (error > PK_WARN) {/* don't print redundant CRC error if error already */
  1218.         undefer_input(__G);
  1219.         return error;
  1220.     }
  1221.     if (G.crc32val != G.lrec.crc32) {
  1222.         /* if quiet enough, we haven't output the filename yet:  do it */
  1223.         if ((G.tflag && G.qflag) || (!G.tflag && !QCOND2))
  1224.             Info(slide, 0x401, ((char *)slide, "%-22s ", G.filename));
  1225.         Info(slide, 0x401, ((char *)slide, LoadFarString(BadCRC), G.crc32val,
  1226.           G.lrec.crc32));
  1227. #ifdef CRYPT
  1228.         if (G.pInfo->encrypted)
  1229.             Info(slide, 0x401, ((char *)slide, LoadFarString(MaybeBadPasswd)));
  1230. #endif
  1231.         error = PK_ERR;
  1232.     } else if (G.tflag) {
  1233.         if (G.extra_field) {
  1234.             if ((r = TestExtraField(__G__ G.extra_field,
  1235.                                     G.lrec.extra_field_length)) > error)
  1236.                 error = r;
  1237.         } else if (!G.qflag)
  1238.             Info(slide, 0, ((char *)slide, " OK\n"));
  1239.     } else {
  1240.         if (QCOND2 && !error)   /* GRR:  is stdout reset to text mode yet? */
  1241.             Info(slide, 0, ((char *)slide, "\n"));
  1242.     }
  1243.  
  1244.     undefer_input(__G);
  1245.     return error;
  1246.  
  1247. } /* end function extract_or_test_member() */
  1248.  
  1249.  
  1250.  
  1251.  
  1252.  
  1253. /*******************************/
  1254. /*  Function TestExtraField()  */
  1255. /*******************************/
  1256.  
  1257. static int TestExtraField(__G__ ef, ef_len)
  1258.     __GDEF
  1259.     uch *ef;
  1260.     unsigned ef_len;
  1261. {
  1262.     ush ebID;
  1263.     unsigned ebLen;
  1264.     int r;
  1265.  
  1266.     /* we know the regular compressed file data tested out OK, or else we
  1267.      * wouldn't be here ==> print filename if any extra-field errors found
  1268.      */
  1269.     while (ef_len >= EB_HEADSIZE) {
  1270.         ebID = makeword(ef);
  1271.         ebLen = (unsigned)makeword(ef+EB_LEN);
  1272.  
  1273.         if (ebLen > (ef_len - EB_HEADSIZE)) {
  1274.            /* Discovered some extra field inconsistency! */
  1275.             if (G.qflag)
  1276.                 Info(slide, 1, ((char *)slide, "%-22s ", G.filename));
  1277.             Info(slide, 1, ((char *)slide, LoadFarString(InconsistEFlength),
  1278.               ebLen, (ef_len - EB_HEADSIZE)));
  1279.             return PK_ERR;
  1280.         }
  1281.  
  1282.         switch (ebID) {
  1283.             case EF_OS2:
  1284.                 if ((r = test_OS2(__G__ ef, ebLen)) != PK_OK) {
  1285.                     if (G.qflag)
  1286.                         Info(slide, 1, ((char *)slide, "%-22s ", G.filename));
  1287.                     switch (r) {
  1288.                         case IZ_EF_TRUNC:
  1289.                             Info(slide, 1, ((char *)slide,
  1290.                               LoadFarString(TruncEAs),
  1291.                               makeword(ef+2)-10, "\n"));
  1292.                             break;
  1293.                         case PK_ERR:
  1294.                             Info(slide, 1, ((char *)slide,
  1295.                               LoadFarString(InvalidComprDataEAs)));
  1296.                             break;
  1297.                         case PK_MEM3:
  1298.                         case PK_MEM4:
  1299.                             Info(slide, 1, ((char *)slide,
  1300.                               LoadFarString(NotEnoughMemEAs)));
  1301.                             break;
  1302.                         default:
  1303.                             if ((r & 0xff) != PK_ERR)
  1304.                                 Info(slide, 1, ((char *)slide,
  1305.                                   LoadFarString(UnknErrorEAs)));
  1306.                             else {
  1307.                                 ush m = (ush)(r >> 8);
  1308.                                 if (m == DEFLATED)            /* GRR KLUDGE! */
  1309.                                     Info(slide, 1, ((char *)slide,
  1310.                                       LoadFarString(BadCRC_EAs)));
  1311.                                 else
  1312.                                     Info(slide, 1, ((char *)slide,
  1313.                                       LoadFarString(UnknComprMethodEAs), m));
  1314.                             }
  1315.                             break;
  1316.                     }
  1317.                     return r;
  1318.                 }
  1319.                 break;
  1320.  
  1321.             case EF_PKVMS:
  1322.             case EF_ASIUNIX:
  1323.             case EF_IZVMS:
  1324.             case EF_IZUNIX:
  1325.             case EF_VMCMS:
  1326.             case EF_MVS:
  1327.             case EF_SPARK:
  1328.             case EF_AV:
  1329.             default:
  1330.                 break;
  1331.         }
  1332.         ef_len -= (ebLen + EB_HEADSIZE);
  1333.         ef += (ebLen + EB_HEADSIZE);
  1334.     }
  1335.  
  1336.     if (!G.qflag)
  1337.         Info(slide, 0, ((char *)slide, " OK\n"));
  1338.  
  1339.     return PK_COOL;
  1340.  
  1341. } /* end function TestExtraField() */
  1342.  
  1343.  
  1344.  
  1345.  
  1346.  
  1347. /*************************/
  1348. /*  Function test_OS2()  */
  1349. /*************************/
  1350.  
  1351. static int test_OS2(__G__ eb, eb_size)
  1352.     __GDEF
  1353.     uch *eb;
  1354.     unsigned eb_size;
  1355. {
  1356.     ulg eb_ucsize = makelong(eb+4);
  1357.     uch *eb_uncompressed;
  1358.     int r;
  1359.  
  1360.     if (eb_ucsize > 0L && eb_size <= 10)
  1361.         return IZ_EF_TRUNC;               /* no compressed data! */
  1362.  
  1363.     if ((eb_uncompressed = (uch *)malloc((size_t)eb_ucsize)) == (uch *)NULL)
  1364.         return PK_MEM4;
  1365.  
  1366.     r = memextract(__G__ eb_uncompressed, eb_ucsize, eb+8, (ulg)(eb_size-4));
  1367.     free(eb_uncompressed);
  1368.     return r;
  1369.  
  1370. } /* end function test_OS2() */
  1371.  
  1372.  
  1373.  
  1374.  
  1375.  
  1376. /***************************/
  1377. /*  Function memextract()  */
  1378. /***************************/
  1379.  
  1380. int memextract(__G__ tgt, tgtsize, src, srcsize)  /* extract compressed */
  1381.     __GDEF                                        /*  extra field block; */
  1382.     uch *tgt, *src;                               /*  return PK-type error */
  1383.     ulg tgtsize, srcsize;                         /*  level */
  1384. {
  1385.     uch *old_inptr=G.inptr;
  1386.     int  old_incnt=G.incnt, r, error=PK_OK;
  1387.     ush  method;
  1388.     ulg  extra_field_crc;
  1389.  
  1390.  
  1391.     method = makeword(src);
  1392.     extra_field_crc = makelong(src+2);
  1393.  
  1394.     /* compressed extra field exists completely in memory at this location: */
  1395.     G.inptr = src + 2 + 4;      /* method and extra_field_crc */
  1396.     G.incnt = (int)(G.csize = (long)(srcsize - (2 + 4)));
  1397.     G.mem_mode = TRUE;
  1398.     G.outbufptr = tgt;
  1399.     G.outsize = tgtsize;
  1400.  
  1401.     switch (method) {
  1402.         case STORED:
  1403.             memcpy((char *)tgt, (char *)G.inptr, (extent)G.incnt);
  1404.             G.outcnt = G.csize;   /* for CRC calculation */
  1405.             break;
  1406.         case DEFLATED:
  1407.             G.outcnt = 0L;
  1408.             if ((r = UZinflate(__G)) != 0) {
  1409.                 if (!G.tflag)
  1410.                     Info(slide, 0x401, ((char *)slide,
  1411.                       LoadFarStringSmall(ErrUnzipNoFile), r == 3?
  1412.                       LoadFarString(NotEnoughMem) :
  1413.                       LoadFarString(InvalidComprData),
  1414.                       LoadFarStringSmall2(Inflate)));
  1415.                 error = (r == 3)? PK_MEM3 : PK_ERR;
  1416.             }
  1417.             if (G.outcnt == 0L)   /* inflate's final FLUSH sets outcnt */
  1418.                 break;
  1419.             break;
  1420.         default:
  1421.             if (G.tflag)
  1422.                 error = PK_ERR | ((int)method << 8);
  1423.             else {
  1424.                 Info(slide, 0x401, ((char *)slide,
  1425.                   LoadFarString(UnsupportedExtraField), method));
  1426.                 error = PK_ERR;  /* GRR:  should be passed on up via SetEAs() */
  1427.             }
  1428.             break;
  1429.     }
  1430.  
  1431.     G.inptr = old_inptr;
  1432.     G.incnt = old_incnt;
  1433.     G.mem_mode = FALSE;
  1434.  
  1435.     if (!error) {
  1436.         register ulg crcval = crc32(CRCVAL_INITIAL, tgt, (extent)G.outcnt);
  1437.  
  1438.         if (crcval != extra_field_crc) {
  1439.             if (G.tflag)
  1440.                 error = PK_ERR | (DEFLATED << 8);  /* kludge for now */
  1441.             else {
  1442.                 Info(slide, 0x401, ((char *)slide,
  1443.                   LoadFarString(BadExtraFieldCRC), G.zipfn, crcval,
  1444.                   extra_field_crc));
  1445.                 error = PK_ERR;
  1446.             }
  1447.         }
  1448.     }
  1449.     return error;
  1450.  
  1451. } /* end function memextract() */
  1452.  
  1453.  
  1454.  
  1455.  
  1456.  
  1457. /*************************/
  1458. /*  Function memflush()  */
  1459. /*************************/
  1460.  
  1461. int memflush(__G__ rawbuf, size)
  1462.     __GDEF
  1463.     uch *rawbuf;
  1464.     ulg size;
  1465. {
  1466.     if (size > G.outsize)
  1467.         return 50;   /* more data than output buffer can hold */
  1468.  
  1469.     memcpy((char *)G.outbufptr, (char *)rawbuf, (extent)size);
  1470.     G.outbufptr += (unsigned int)size;
  1471.     G.outsize -= size;
  1472.     G.outcnt += size;
  1473.  
  1474.     return 0;
  1475.  
  1476. } /* end function memflush() */
  1477.  
  1478.  
  1479.  
  1480.  
  1481.  
  1482. /*************************/
  1483. /*  Function fnfilter()  */        /* here instead of in list.c for SFX */
  1484. /*************************/
  1485.  
  1486. char *fnfilter(raw, space)         /* convert name to safely printable form */
  1487.     char *raw;
  1488.     uch *space;
  1489. {
  1490. #ifndef NATIVE   /* ASCII:  filter ANSI escape codes, etc. */
  1491.     register uch *r=(uch *)raw, *s=space;
  1492.     while (*r)
  1493.         if (*r < 32)
  1494.             *s++ = '^', *s++ = (uch)(64 + *r++);
  1495.         else
  1496.             *s++ = *r++;
  1497.     *s = 0;
  1498.     return (char *)space;
  1499. #else
  1500.     return raw;
  1501. #endif
  1502. } /* end function fnfilter() */
  1503.